home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / imagehlp.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1998-02-09  |  31.3 KB  |  748 lines
  1. {*******************************************************}
  2. {                                                       }
  3. {       Delphi Run-time Library                         }
  4. {       Prototypes and constants required for the       }
  5. {       Win32 image help routines.                      }
  6. {                                                       }
  7. {       Copyright (c) 1996,1998 Borland International   }
  8. {                                                       }
  9. {*******************************************************}
  10.  
  11. unit Imagehlp;
  12.  
  13. interface
  14.  
  15. {$HPPEMIT '#include <imagehlp.h>'}
  16.  
  17. uses Windows;
  18.  
  19. { Define checksum return codes. }
  20. const
  21.   {$EXTERNALSYM CHECKSUM_SUCCESS}
  22.   CHECKSUM_SUCCESS                = 0;
  23.   {$EXTERNALSYM CHECKSUM_OPEN_FAILURE}
  24.   CHECKSUM_OPEN_FAILURE           = 1;
  25.   {$EXTERNALSYM CHECKSUM_MAP_FAILURE}
  26.   CHECKSUM_MAP_FAILURE            = 2;
  27.   {$EXTERNALSYM CHECKSUM_MAPVIEW_FAILURE}
  28.   CHECKSUM_MAPVIEW_FAILURE        = 3;
  29.   {$EXTERNALSYM CHECKSUM_UNICODE_FAILURE}
  30.   CHECKSUM_UNICODE_FAILURE        = 4;
  31.  
  32. { Define Splitsym flags. }
  33.  
  34.   {$EXTERNALSYM SPLITSYM_REMOVE_PRIVATE}
  35.   SPLITSYM_REMOVE_PRIVATE         = $00000001;      { Remove CV types/symbols and Fixup debug }
  36. {  Used for creating .dbg files that ship }
  37. {  as part of the product. }
  38.  
  39.   {$EXTERNALSYM SPLITSYM_EXTRACT_ALL}
  40.   SPLITSYM_EXTRACT_ALL            = $00000002;      { Extract all debug info from image. }
  41. {  Normally, FPO is left in the image }
  42. {  to allow stack traces through the code. }
  43. {  Using this switch is similar to linking }
  44. {  with -debug:none except the .dbg file }
  45. {  exists... }
  46.  
  47. { Define checksum function prototypes. }
  48. {$EXTERNALSYM CheckSumMappedFile}
  49. function CheckSumMappedFile(BaseAddress: Pointer; FileLength: DWORD;
  50.   HeaderSum: PDWORD; CheckSum: PDWORD): PImageNtHeaders; stdcall;
  51.  
  52. {$EXTERNALSYM MapFileAndCheckSumA}
  53. function MapFileAndCheckSumA(Filename: PAnsiChar; var HeaderSum,
  54.   CheckSum: DWORD): DWORD; stdcall;
  55. {$EXTERNALSYM MapFileAndCheckSumW}
  56. function MapFileAndCheckSumW(Filename: PWideChar; var HeaderSum,
  57.   CheckSum: DWORD): DWORD; stdcall;
  58. {$EXTERNALSYM MapFileAndCheckSum}
  59. function MapFileAndCheckSum(Filename: PChar; var HeaderSum,
  60.   CheckSum: DWORD): DWORD; stdcall;
  61.  
  62.  
  63. {$EXTERNALSYM TouchFileTimes}
  64. function TouchFileTimes(FileHandle: THandle; const lpSystemTime: TSystemTime):
  65.   Bool; stdcall;
  66.  
  67. {$EXTERNALSYM SplitSymbols}
  68. function SplitSymbols(ImageName, SymbolsPath, SymbolFilePath: LPSTR;
  69.   Flags: DWORD): Bool; stdcall;
  70.  
  71. {$EXTERNALSYM FindDebugInfoFile}
  72. function FindDebugInfoFile(FileName, SymbolPath, DebugFilePath: LPSTR): THandle; stdcall;
  73.  
  74. {$EXTERNALSYM FindExecutableImage}
  75. function FindExecutableImage(FileName, SymbolPath, ImageFilePath: LPSTR): THandle; stdcall;
  76.  
  77. {$EXTERNALSYM UpdateDebugInfoFile}
  78. function UpdateDebugInfoFile(ImageFileName, SymbolPath, DebugFilePath: LPSTR;
  79.   NtHeaders: PImageNtHeaders): Bool; stdcall;
  80.  
  81. {$EXTERNALSYM UpdateDebugInfoFileEx}
  82. function UpdateDebugInfoFileEx(ImageFileName, SymbolPath, DebugFilePath: LPSTR;
  83.   NtHeaders: PImageNtHeaders; OldChecksum: DWORD): Bool; stdcall;
  84.  
  85. {$EXTERNALSYM BindImage}
  86. function BindImage(ImageName, DllPath, SymbolPath: LPSTR): Bool; stdcall;
  87.  
  88. type
  89.   {$EXTERNALSYM _IMAGEHLP_STATUS_REASON}
  90.   _IMAGEHLP_STATUS_REASON = (
  91.     BindOutOfMemory,
  92.     BindRvaToVaFailed,
  93.     BindNoRoomInImage,
  94.     BindImportModuleFailed,
  95.     BindImportProcedureFailed,
  96.     BindImportModule,
  97.     BindImportProcedure,
  98.     BindForwarder,
  99.     BindForwarderNOT,
  100.     BindImageModified,
  101.     BindExpandFileHeaders,
  102.     BindImageComplete,
  103.     BindMismatchedSymbols,
  104.     BindSymbolsNotUpdated
  105.   );
  106.   {$EXTERNALSYM IMAGEHLP_STATUS_REASON}
  107.   IMAGEHLP_STATUS_REASON = _IMAGEHLP_STATUS_REASON;
  108.   TImagehlpStatusReason = _IMAGEHLP_STATUS_REASON;
  109.  
  110. type
  111.   {$EXTERNALSYM PIMAGEHLP_STATUS_ROUTINE}
  112.   PIMAGEHLP_STATUS_ROUTINE = function(Reason: TImagehlpStatusReason;
  113.     ImageName, DllName: LPSTR; Va, Parameter: ULONG): Bool; stdcall;
  114.   TImagehlpStatusRoutine = PIMAGEHLP_STATUS_ROUTINE;
  115.  
  116. {$EXTERNALSYM BindImageEx}
  117. function BindImageEx(Flags: DWORD; ImageName, DllPath, SymbolPath: LPSTR;
  118.   var StatusRoutine: TImagehlpStatusReason): Bool; stdcall;
  119.  
  120. const
  121.   {$EXTERNALSYM BIND_NO_BOUND_IMPORTS}
  122.   BIND_NO_BOUND_IMPORTS     = $00000001;
  123.   {$EXTERNALSYM BIND_NO_UPDATE}
  124.   BIND_NO_UPDATE            = $00000002;
  125.   {$EXTERNALSYM BIND_ALL_IMAGES}
  126.   BIND_ALL_IMAGES           = $00000004;
  127.  
  128. {$EXTERNALSYM ReBaseImage}
  129. function ReBaseImage(CurrentImageName, SymbolPath: LPSTR; fReBase,
  130.   fRebaseSysfileOk, fGoingDown: Bool; CheckImageSize: ULONG;
  131.   var OldImageSize, OldImageBase, NewImageSize, NewImageBase: ULONG;
  132.   TimeStamp: ULONG): Bool; stdcall;
  133.  
  134. const
  135.   {$EXTERNALSYM IMAGE_SEPARATION}
  136.   IMAGE_SEPARATION     = 64 * 1024;
  137.  
  138. type
  139.   PloadedImage = ^LoadedImage;
  140.   {$EXTERNALSYM _LOADED_IMAGE}
  141.   _LOADED_IMAGE = packed record
  142.     ModuleName: LPSTR;
  143.     hFile: THandle;
  144.     MappedAddress: PChar;
  145.     FileHeader: PImageNtHeaders;
  146.     LastRvaSection: PImageSectionHeader;
  147.     NumberOfSections: ULONG;
  148.     Sections: PImageSectionHeader;
  149.     Characteristics: ULONG;
  150.     fSystemImage: ByteBool;
  151.     fDOSImage: ByteBool;
  152.     Links: TListEntry;
  153.     SizeOfImage: ULONG;
  154.   end;
  155.   {$EXTERNALSYM LOADED_IMAGE}
  156.   LOADED_IMAGE = _LOADED_IMAGE;
  157.   LoadedImage = _LOADED_IMAGE;
  158.  
  159.  
  160. {$EXTERNALSYM ImageLoad}
  161. function ImageLoad(DllName, DllPath: LPSTR): PLoadedImage; stdcall;
  162.  
  163. {$EXTERNALSYM ImageUnload}
  164. function ImageUnload(LoadedImage: PLoadedImage): Bool; stdcall;
  165.  
  166. {$EXTERNALSYM ImageNtHeader}
  167. function ImageNtHeader(Base: Pointer): PImageNtHeaders; stdcall;
  168.  
  169. {$EXTERNALSYM ImageDirectoryEntryToData}
  170. function ImageDirectoryEntryToData(Base: Pointer; MappedAsImage: ByteBool;
  171.   DirectoryEntry: Word; var Size: ULONG): Pointer; stdcall;
  172.  
  173. {$EXTERNALSYM ImageRvaToSection}
  174. function ImageRvaToSection(NtHeaders: PImageNtHeaders; Base: Pointer;
  175.   Rva: ULONG): PImageSectionHeader; stdcall;
  176.  
  177. {$EXTERNALSYM ImageRvaToVa}
  178. function ImageRvaToVa(NtHeaders: PImageNtHeaders; Base: Pointer;
  179.   Rva: ULONG; var LastRvaSection: PImageSectionHeader): Pointer; stdcall;
  180.  
  181. {$EXTERNALSYM MapAndLoad}
  182. function MapAndLoad(ImageName, DllPath: LPSTR; LoadedImage: PLoadedImage;
  183.   DotDll, ReadOnly: Bool): Bool; stdcall;
  184.  
  185. {$EXTERNALSYM GetImageConfigInformation}
  186. function GetImageConfigInformation(LoadedImage: PLoadedImage;
  187.   var ImageConfigInformation: TImageLoadConfigDirectory): Bool; stdcall;
  188.  
  189. {$EXTERNALSYM GetImageUnusedHeaderBytes}
  190. function GetImageUnusedHeaderBytes(LoadedImage: PLoadedImage;
  191.   var SizeUnusedHeaderBytes: DWORD): DWORD; stdcall;
  192.  
  193. {$EXTERNALSYM SetImageConfigInformation}
  194. function SetImageConfigInformation(LoadedImage: PLoadedImage;
  195.   const ImageConfigInformation: TImageLoadConfigDirectory): Bool; stdcall;
  196.  
  197. {$EXTERNALSYM UnMapAndLoad}
  198. function UnMapAndLoad(LoadedImage: PLoadedImage): Bool; stdcall;
  199.  
  200. type
  201.   PimageDebugInformation = ^TImageDebugInformation;
  202.   {$EXTERNALSYM _IMAGE_DEBUG_INFORMATION}
  203.   _IMAGE_DEBUG_INFORMATION = packed record
  204.     List: TListEntry;
  205.     Size: DWORD;
  206.     MappedBase: Pointer;
  207.     Machine: Word;
  208.     Characteristics: Word;
  209.     CheckSum: DWORD;
  210.     ImageBase: DWORD;
  211.     SizeOfImage: DWORD;
  212.     NumberOfSections: DWORD;
  213.     Sections: PImageSectionHeader;
  214.     ExportedNamesSize: DWORD;
  215.     ExportedNames: LPSTR;
  216.     NumberOfFunctionTableEntries: DWORD;
  217.     FunctionTableEntries: PImageFunctionEntry;
  218.     LowestFunctionStartingAddress: DWORD;
  219.     HighestFunctionEndingAddress: DWORD;
  220.     NumberOfFpoTableEntries: DWORD;
  221.     FpoTableEntries: PFpoData;
  222.     SizeOfCoffSymbols: DWORD;
  223.     CoffSymbols: PImageCOFFSymbolsHeader;
  224.     SizeOfCodeViewSymbols: DWORD;
  225.     CodeViewSymbols: Pointer;
  226.     ImageFilePath: LPSTR;
  227.     ImageFileName: LPSTR;
  228.     DebugFilePath: LPSTR;
  229.     TimeDateStamp: DWORD;
  230.     RomImage: Bool;
  231.     DebugDirectory: PImageDebugDirectory;
  232.     NumberOfDebugDirectories: DWORD;
  233.     Reserved: packed array[0..2] of DWORD;
  234.   end;
  235.   {$EXTERNALSYM IMAGE_DEBUG_INFORMATION}
  236.   IMAGE_DEBUG_INFORMATION = _IMAGE_DEBUG_INFORMATION;
  237.   TImageDebugInformation = _IMAGE_DEBUG_INFORMATION;
  238.  
  239. {$EXTERNALSYM MapDebugInformation}
  240. function MapDebugInformation(FileHandle: THandle; FileName, SymbolPath: LPSTR;
  241.   ImageBase: DWORD): PImageDebugInformation; stdcall;
  242.  
  243. {$EXTERNALSYM UnmapDebugInformation}
  244. function UnmapDebugInformation(DebugInfo: PImageDebugInformation): Bool; stdcall;
  245.  
  246. {$EXTERNALSYM SearchTreeForFile}
  247. function SearchTreeForFile(RootPath, InputPathName, OutputPathBuffer: LPSTR):
  248.   Bool; stdcall;
  249.  
  250. {$EXTERNALSYM MakeSureDirectoryPathExists}
  251. function MakeSureDirectoryPathExists(DirPath: LPCSTR): Bool; stdcall;
  252.  
  253. { UnDecorateSymbolName Flags }
  254. const
  255.   {$EXTERNALSYM UNDNAME_COMPLETE}
  256.   UNDNAME_COMPLETE                     = $0000;    { Enable full undecoration }
  257.   {$EXTERNALSYM UNDNAME_NO_LEADING_UNDERSCORES}
  258.   UNDNAME_NO_LEADING_UNDERSCORES       = $0001;    { Remove leading underscores from MS extended keywords }
  259.   {$EXTERNALSYM UNDNAME_NO_MS_KEYWORDS}
  260.   UNDNAME_NO_MS_KEYWORDS               = $0002;    { Disable expansion of MS extended keywords }
  261.   {$EXTERNALSYM UNDNAME_NO_FUNCTION_RETURNS}
  262.   UNDNAME_NO_FUNCTION_RETURNS          = $0004;    { Disable expansion of return type for primary declaration }
  263.   {$EXTERNALSYM UNDNAME_NO_ALLOCATION_MODEL}
  264.   UNDNAME_NO_ALLOCATION_MODEL          = $0008;    { Disable expansion of the declaration model }
  265.   {$EXTERNALSYM UNDNAME_NO_ALLOCATION_LANGUAGE}
  266.   UNDNAME_NO_ALLOCATION_LANGUAGE       = $0010;    { Disable expansion of the declaration language specifier }
  267.   {$EXTERNALSYM UNDNAME_NO_MS_THISTYPE}
  268.   UNDNAME_NO_MS_THISTYPE               = $0020;    { NYI Disable expansion of MS keywords on the 'this' type for primary declaration }
  269.   {$EXTERNALSYM UNDNAME_NO_CV_THISTYPE}
  270.   UNDNAME_NO_CV_THISTYPE               = $0040;    { NYI Disable expansion of CV modifiers on the 'this' type for primary declaration }
  271.   {$EXTERNALSYM UNDNAME_NO_THISTYPE}
  272.   UNDNAME_NO_THISTYPE                  = $0060;    { Disable all modifiers on the 'this' type }
  273.   {$EXTERNALSYM UNDNAME_NO_ACCESS_SPECIFIERS}
  274.   UNDNAME_NO_ACCESS_SPECIFIERS         = $0080;    { Disable expansion of access specifiers for members }
  275.   {$EXTERNALSYM UNDNAME_NO_THROW_SIGNATURES}
  276.   UNDNAME_NO_THROW_SIGNATURES          = $0100;    { Disable expansion of 'throw-signatures' for functions and pointers to functions }
  277.   {$EXTERNALSYM UNDNAME_NO_MEMBER_TYPE}
  278.   UNDNAME_NO_MEMBER_TYPE               = $0200;    { Disable expansion of 'static' or 'virtual'ness of members }
  279.   {$EXTERNALSYM UNDNAME_NO_RETURN_UDT_MODEL}
  280.   UNDNAME_NO_RETURN_UDT_MODEL          = $0400;    { Disable expansion of MS model for UDT returns }
  281.   {$EXTERNALSYM UNDNAME_32_BIT_DECODE}
  282.   UNDNAME_32_BIT_DECODE                = $0800;    { Undecorate 32-bit decorated names }
  283.   {$EXTERNALSYM UNDNAME_NAME_ONLY}
  284.   UNDNAME_NAME_ONLY                    = $1000;    { Crack only the name for primary declaration; }
  285. {  return just [scope::]name.  Does expand template params }
  286.   {$EXTERNALSYM UNDNAME_NO_ARGUMENTS}
  287.   UNDNAME_NO_ARGUMENTS                 = $2000;    { Don't undecorate arguments to function }
  288.   {$EXTERNALSYM UNDNAME_NO_SPECIAL_SYMS}
  289.   UNDNAME_NO_SPECIAL_SYMS              = $4000;    { Don't undecorate special names (v-table, vcall, vector xxx, metatype, etc) }
  290.  
  291. {$EXTERNALSYM UnDecorateSymbolName}
  292. function UnDecorateSymbolName(DecoratedName, UnDecoratedName: LPSTR;
  293.   UndecoratedLength, Flags: DWORD): DWORD; stdcall;
  294.  
  295.  
  296. { StackWalking API }
  297. type
  298.   {$EXTERNALSYM ADDRESS_MODE}
  299.   ADDRESS_MODE = (
  300.     AddrMode1616,
  301.     AddrMode1632,
  302.     AddrModeReal,
  303.     AddrModeFlat
  304.   );
  305.   TAddressMode = ADDRESS_MODE;
  306.  
  307.   PAddress = ^TAddress;
  308.   {$EXTERNALSYM _tagADDRESS}
  309.   _tagADDRESS = packed record
  310.     Offset: DWORD;
  311.     Segment: Word;
  312.     Mode: TAddressMode;
  313.   end;
  314.   {$EXTERNALSYM ADDRESS}
  315.   ADDRESS = _tagADDRESS;
  316.   TAddress = _tagADDRESS;
  317.  
  318. { This structure is included in the STACKFRAME structure, }
  319. { and is used to trace through usermode callbacks in a thread's }
  320. { kernel stack.  The values must be copied by the kernel debugger }
  321. { from the DBGKD_GET_VERSION and WAIT_STATE_CHANGE packets. }
  322.  
  323.   PKdHelp = ^TKdHelp;
  324.   {$EXTERNALSYM _KDHELP}
  325.   _KDHELP = packed record { address of kernel thread object, as provided }
  326.                           { in the WAIT_STATE_CHANGE packet. }
  327.     Thread: DWORD;
  328.     { offset in thread object to pointer to the current callback frame }
  329.     { in kernel stack. }
  330.     ThCallbackStack: DWORD;
  331.     { offsets to values in frame: }
  332.     { address of next callback frame }
  333.     NextCallback: DWORD;
  334.     { address of saved frame pointer (if applicable) }
  335.     FramePointer: DWORD;
  336.     { Address of the kernel function that calls out to user mode }
  337.     KiCallUserMode: DWORD;
  338.     { Address of the user mode dispatcher function }
  339.     KeUserCallbackDispatcher: DWORD;
  340.   end;
  341.   {$EXTERNALSYM KDHELP}
  342.   KDHELP = _KDHELP;
  343.   TKdHelp = _KDHELP;
  344.  
  345.   PStackFrame = ^TStackFrame;
  346.   {$EXTERNALSYM _tagSTACKFRAME}
  347.   _tagSTACKFRAME = packed record
  348.     AddrPC: TAddress;                  { program counter }
  349.     AddrReturn: TAddress;              { return address }
  350.     AddrFrame: TAddress;               { frame pointer }
  351.     AddrStack: TAddress;               { stack pointer }
  352.     FuncTableEntry: Pointer;          { pointer to pdata/fpo or NULL }
  353.     Params: packed array[0..3] of DWORD;{ possible arguments to the function }
  354.     _Far: Bool;                        { WOW far call }
  355.     _Virtual: Bool;                    { is this a virtual frame? }
  356.     Reserved: packed array[0..2] of DWORD;{ used internally by StackWalk api }
  357.     KdHelp: TKdHelp;
  358.   end;
  359.   {$EXTERNALSYM STACKFRAME}
  360.   STACKFRAME = _tagSTACKFRAME;
  361.   TStackFrame = _tagSTACKFRAME;
  362.  
  363. type
  364.   {$EXTERNALSYM PREAD_PROCESS_MEMORY_ROUTINE}
  365.   PREAD_PROCESS_MEMORY_ROUTINE = function(hProcess: THandle;
  366.     lpBaseAddress, lpBuffer: Pointer; nSize: DWORD;
  367.     var lpNumberOfBytesRead: DWORD): Bool; stdcall;
  368.   TReadProcessMemoryRoutine = PREAD_PROCESS_MEMORY_ROUTINE;
  369.  
  370.   {$EXTERNALSYM PFUNCTION_TABLE_ACCESS_ROUTINE}
  371.   PFUNCTION_TABLE_ACCESS_ROUTINE = function(hProcess: THandle;
  372.     AddrBase: DWORD): Pointer; stdcall;
  373.   TFunctionTableAccessRoutine = PFUNCTION_TABLE_ACCESS_ROUTINE;
  374.  
  375.   {$EXTERNALSYM PGET_MODULE_BASE_ROUTINE}
  376.   PGET_MODULE_BASE_ROUTINE = function(hProcess: THandle;
  377.     ReturnAddress: DWORD): DWORD; stdcall;
  378.   TGetModuleBaseRoutine = PGET_MODULE_BASE_ROUTINE;
  379.  
  380.   {$EXTERNALSYM PTRANSLATE_ADDRESS_ROUTINE}
  381.   PTRANSLATE_ADDRESS_ROUTINE = function(hProcess, hThread: THandle;
  382.     lpaddr: PAddress): DWORD; stdcall;
  383.   TTranslateAddressRoutine = PTRANSLATE_ADDRESS_ROUTINE;
  384.  
  385. {$EXTERNALSYM StackWalk}
  386. function StackWalk(MachineType: DWORD; hProcess, hThread: THandle;
  387.   StackFrame: PStackFrame; ContextRecord: Pointer;
  388.   ReadMemoryRoutine: TReadProcessMemoryRoutine;
  389.   FunctionTableAccessRoutine: TFunctionTableAccessRoutine;
  390.   GetModuleBaseRoutine: TGetModuleBaseRoutine;
  391.   TranslateAddress: TTranslateAddressRoutine): Bool; stdcall;
  392.  
  393. const
  394.   {$EXTERNALSYM API_VERSION_NUMBER}
  395.   API_VERSION_NUMBER     = 5;
  396.  
  397. type
  398.   PApiVersion = ^TApiVersion;
  399.   {$EXTERNALSYM API_VERSION}
  400.   API_VERSION = packed record
  401.     MajorVersion: Word;
  402.     MinorVersion: Word;
  403.     Revision: Word;
  404.     Reserved: Word;
  405.   end;
  406.   TApiVersion = API_VERSION;
  407.  
  408. {$EXTERNALSYM ImagehlpApiVersion}
  409. function ImagehlpApiVersion: PApiVersion; stdcall;
  410.  
  411. {$EXTERNALSYM ImagehlpApiVersionEx}
  412. function ImagehlpApiVersionEx(var AppVersion: TApiVersion): PApiVersion; stdcall;
  413.  
  414. {$EXTERNALSYM GetTimestampForLoadedLibrary}
  415. function GetTimestampForLoadedLibrary(Module: HMODULE): DWORD; stdcall;
  416.  
  417. {$EXTERNALSYM RemovePrivateCvSymbolic}
  418. function RemovePrivateCvSymbolic(DebugData: PChar; var NewDebugData: PChar;
  419.   var NewDebugSize: ULONG): Bool; stdcall;
  420.  
  421. {$EXTERNALSYM RemoveRelocations}
  422. procedure RemoveRelocations(ImageName: PChar); stdcall;
  423.  
  424.  
  425. { typedefs for function pointers }
  426. type
  427.   {$EXTERNALSYM PSYM_ENUMMODULES_CALLBACK}
  428.   PSYM_ENUMMODULES_CALLBACK = function(ModuleName: LPSTR; BaseOfDll: ULONG;
  429.     UserContext: Pointer): Bool; stdcall;
  430.   TSymEnummodulesCallback = PSYM_ENUMMODULES_CALLBACK;
  431.  
  432.   {$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACK}
  433.   PSYM_ENUMSYMBOLS_CALLBACK = function(SymbolName: LPSTR; SymbolAddress,
  434.     SymbolSize: ULONG; UserContext: Pointer): Bool; stdcall;
  435.   TSymEnumsymbolsCallback = PSYM_ENUMSYMBOLS_CALLBACK;
  436.  
  437.   {$EXTERNALSYM PENUMLOADED_MODULES_CALLBACK}
  438.   PENUMLOADED_MODULES_CALLBACK = function(ModuleName: LPSTR; ModuleBase,
  439.     ModuleSize: ULONG; UserContext: Pointer): Bool; stdcall;
  440.   TEnumloadedModulesCallback = PENUMLOADED_MODULES_CALLBACK;
  441.  
  442.   {$EXTERNALSYM PSYMBOL_REGISTERED_CALLBACK}
  443.   PSYMBOL_REGISTERED_CALLBACK = function(hProcess: THandle; ActionCode: ULONG;
  444.     CallbackData, UserContext: Pointer): Bool; stdcall;
  445.   TSymbolRegisteredCallback = PSYMBOL_REGISTERED_CALLBACK;
  446.  
  447.  
  448. { symbol flags }
  449. const
  450.   {$EXTERNALSYM SYMF_OMAP_GENERATED}
  451.   SYMF_OMAP_GENERATED       = $00000001;
  452.   {$EXTERNALSYM SYMF_OMAP_MODIFIED}
  453.   SYMF_OMAP_MODIFIED        = $00000002;
  454.  
  455.  
  456. { symbol type enumeration }
  457. type
  458.   {$EXTERNALSYM SYM_TYPE}
  459.   SYM_TYPE = (
  460.     SymNone,
  461.     SymCoff,
  462.     SymCv,
  463.     SymPdb,
  464.     SymExport,
  465.     SymDeferred,
  466.     SymSym                  { .sym file }
  467.   );
  468.   TSymType = SYM_TYPE;
  469.  
  470. { symbol data structure }
  471.   PImagehlpSymbol = ^TImagehlpSymbol;
  472.   {$EXTERNALSYM _IMAGEHLP_SYMBOL}
  473.   _IMAGEHLP_SYMBOL = packed record
  474.     SizeOfStruct: DWORD;                                { set to sizeof(IMAGEHLP_SYMBOL) }
  475.     Address: DWORD;                                     { virtual address including dll base address }
  476.     Size: DWORD;                                        { estimated size of symbol, can be zero }
  477.     Flags: DWORD;                                       { info about the symbols, see the SYMF defines }
  478.     MaxNameLength: DWORD;                               { maximum size of symbol name in 'Name' }
  479.     Name: packed array[0..0] of Char;                   { symbol name (null terminated string) }
  480.   end;
  481.   {$EXTERNALSYM IMAGEHLP_SYMBOL}
  482.   IMAGEHLP_SYMBOL = _IMAGEHLP_SYMBOL;
  483.   TImagehlpSymbol = _IMAGEHLP_SYMBOL;
  484.  
  485.  
  486. { module data structure }
  487.   PImagehlpModule = ^TImagehlpModule;
  488.   {$EXTERNALSYM _IMAGEHLP_MODULE}
  489.   _IMAGEHLP_MODULE = packed record
  490.     SizeOfStruct: DWORD;                                { set to sizeof(IMAGEHLP_MODULE) }
  491.     BaseOfImage: DWORD;                                 { base load address of module }
  492.     ImageSize: DWORD;                                   { virtual size of the loaded module }
  493.     TimeDateStamp: DWORD;                               { date/time stamp from pe header }
  494.     CheckSum: DWORD;                                    { checksum from the pe header }
  495.     NumSyms: DWORD;                                     { number of symbols in the symbol table }
  496.     SymType: TSymType;                                  { type of symbols loaded }
  497.     ModuleName: packed array[0..31] of Char;            { module name }
  498.     ImageName: packed array[0..255] of Char;            { image name }
  499.     LoadedImageName: packed array[0..255] of Char;      { symbol file name }
  500.   end;
  501.   {$EXTERNALSYM IMAGEHLP_MODULE}
  502.   IMAGEHLP_MODULE = _IMAGEHLP_MODULE;
  503.   TImagehlpModule = _IMAGEHLP_MODULE;
  504.  
  505.  
  506. { data structures used for registered symbol callbacks }
  507. const
  508.   {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_START}
  509.   CBA_DEFERRED_SYMBOL_LOAD_START              = $00000001;
  510.   {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_COMPLETE}
  511.   CBA_DEFERRED_SYMBOL_LOAD_COMPLETE           = $00000002;
  512.   {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_FAILURE}
  513.   CBA_DEFERRED_SYMBOL_LOAD_FAILURE            = $00000003;
  514.   {$EXTERNALSYM CBA_SYMBOLS_UNLOADED}
  515.   CBA_SYMBOLS_UNLOADED                        = $00000004;
  516.   {$EXTERNALSYM CBA_DUPLICATE_SYMBOL}
  517.   CBA_DUPLICATE_SYMBOL                        = $00000005;
  518.  
  519. type
  520.   PImagehlpDeferredSymbolLoad = ^TImagehlpDeferredSymbolLoad;
  521.   {$EXTERNALSYM _IMAGEHLP_DEFERRED_SYMBOL_LOAD}
  522.   _IMAGEHLP_DEFERRED_SYMBOL_LOAD = packed record
  523.     SizeOfStruct: DWORD;                                { set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD) }
  524.     BaseOfImage: DWORD;                                 { base load address of module }
  525.     CheckSum: DWORD;                                    { checksum from the pe header }
  526.     TimeDateStamp: DWORD;                               { date/time stamp from pe header }
  527.     FileName: packed array[0..MAX_PATH-1] of Char;      { symbols file or image name }
  528.   end;
  529.   {$EXTERNALSYM IMAGEHLP_DEFERRED_SYMBOL_LOAD}
  530.   IMAGEHLP_DEFERRED_SYMBOL_LOAD = _IMAGEHLP_DEFERRED_SYMBOL_LOAD;
  531.   TImagehlpDeferredSymbolLoad = _IMAGEHLP_DEFERRED_SYMBOL_LOAD;
  532.  
  533.   PImagehlpDuplicateSymbol = ^TImagehlpDuplicateSymbol;
  534.   {$EXTERNALSYM _IMAGEHLP_DUPLICATE_SYMBOL}
  535.   _IMAGEHLP_DUPLICATE_SYMBOL = packed record
  536.     SizeOfStruct: DWORD;                                { set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL) }
  537.     NumberOfDups: DWORD;                                { number of duplicates in the Symbol array }
  538.     Symbol: PImagehlpSymbol;                            { array of duplicate symbols }
  539.     SelectedSymbol: ULONG;                           { symbol selected (-1 to start) }
  540.   end;
  541.   {$EXTERNALSYM IMAGEHLP_DUPLICATE_SYMBOL}
  542.   IMAGEHLP_DUPLICATE_SYMBOL = _IMAGEHLP_DUPLICATE_SYMBOL;
  543.   TImagehlpDuplicateSymbol = _IMAGEHLP_DUPLICATE_SYMBOL;
  544.  
  545.  
  546.  
  547. { options that are set/returned by SymSetOptions() & SymGetOptions() }
  548. { these are used as a mask }
  549.  
  550. const
  551.   {$EXTERNALSYM SYMOPT_CASE_INSENSITIVE}
  552.   SYMOPT_CASE_INSENSITIVE      = $00000001;
  553.   {$EXTERNALSYM SYMOPT_UNDNAME}
  554.   SYMOPT_UNDNAME               = $00000002;
  555.   {$EXTERNALSYM SYMOPT_DEFERRED_LOADS}
  556.   SYMOPT_DEFERRED_LOADS        = $00000004;
  557.   {$EXTERNALSYM SYMOPT_NO_CPP}
  558.   SYMOPT_NO_CPP                = $00000008;
  559.  
  560.  
  561. {$EXTERNALSYM SymSetOptions}
  562. function SymSetOptions(SymOptions: DWORD): DWORD; stdcall;
  563.  
  564. {$EXTERNALSYM SymGetOptions}
  565. function SymGetOptions: DWORD; stdcall;
  566.  
  567. {$EXTERNALSYM SymCleanup}
  568. function SymCleanup(hProcess: THandle): Bool; stdcall;
  569.  
  570. {$EXTERNALSYM SymEnumerateModules}
  571. function SymEnumerateModules(hProcess: THandle;
  572.   EnumModulesCallback: TSymEnumModulesCallback; UserContext: Pointer): Bool; stdcall;
  573.  
  574. {$EXTERNALSYM SymEnumerateSymbols}
  575. function SymEnumerateSymbols(hProcess: THandle; BaseOfDll: DWORD;
  576.   EnumSymbolsCallback: TSymEnumSymbolsCallback; UserContext: Pointer): Bool; stdcall;
  577.  
  578. {$EXTERNALSYM EnumerateLoadedModules}
  579. function EnumerateLoadedModules(hProcess: THandle;
  580.   EnumLoadedModulesCallback: TEnumLoadedModulesCallback;
  581.   UserContext: Pointer): Bool; stdcall;
  582.  
  583. {$EXTERNALSYM SymFunctionTableAccess}
  584. function SymFunctionTableAccess(hProcess: THandle; AddrBase: DWORD): Pointer; stdcall;
  585.  
  586. {$EXTERNALSYM SymGetModuleInfo}
  587. function SymGetModuleInfo(hProcess: THandle; dwAddr: DWORD;
  588.   var ModuleInfo: TImagehlpModule): Bool; stdcall;
  589.  
  590. {$EXTERNALSYM SymGetModuleBase}
  591. function SymGetModuleBase(hProcess: THandle; dwAddr: DWORD): DWORD; stdcall;
  592.  
  593. {$EXTERNALSYM SymGetSymFromAddr}
  594. function SymGetSymFromAddr(hProcess: THandle; dwAddr: DWORD;
  595.   pdwDisplacement: PDWORD; var Symbol: TImagehlpSymbol): Bool; stdcall;
  596.  
  597. {$EXTERNALSYM SymGetSymFromName}
  598. function SymGetSymFromName(hProcess: THandle; Name: LPSTR;
  599.   var Symbol: TImagehlpSymbol): Bool; stdcall;
  600.  
  601. {$EXTERNALSYM SymGetSymNext}
  602. function SymGetSymNext(hProcess: THandle; var Symbol: TImagehlpSymbol): Bool; stdcall;
  603.  
  604. {$EXTERNALSYM SymGetSymPrev}
  605. function SymGetSymPrev(hProcess: THandle; var Symbol: TImagehlpSymbol): Bool; stdcall;
  606.  
  607. {$EXTERNALSYM SymInitialize}
  608. function SymInitialize(hProcess: THandle; UserSearchPath: LPSTR;
  609.   fInvadeProcess: Bool): Bool; stdcall;
  610.  
  611. {$EXTERNALSYM SymGetSearchPath}
  612. function SymGetSearchPath(hProcess: THandle; SearchPath: LPSTR;
  613.   SearchPathLength: DWORD): Bool; stdcall;
  614.  
  615. {$EXTERNALSYM SymSetSearchPath}
  616. function SymSetSearchPath(hProcess: THandle; SearchPath: LPSTR): Bool; stdcall;
  617.  
  618. {$EXTERNALSYM SymLoadModule}
  619. function SymLoadModule(hProcess: THandle; hFile: THandle; ImageName,
  620.   ModuleName: LPSTR; BaseOfDll, SizeOfDll: DWORD): Bool; stdcall;
  621.  
  622. {$EXTERNALSYM SymUnloadModule}
  623. function SymUnloadModule(hProcess: THandle; BaseOfDll: DWORD): Bool; stdcall;
  624.  
  625. {$EXTERNALSYM SymUnDName}
  626. function SymUnDName(sym: PImagehlpSymbol; UnDecName: LPSTR;
  627.   UnDecNameLength: DWORD): Bool; stdcall;
  628.  
  629. {$EXTERNALSYM SymRegisterCallback}
  630. function SymRegisterCallback(hProcess: THandle;
  631.   CallbackFunction: TSymbolRegisteredCallback; UserContext: Pointer): Bool; stdcall;
  632.  
  633. { Image Integrity API's }
  634.  
  635. const
  636.   {$EXTERNALSYM CERT_PE_IMAGE_DIGEST_DEBUG_INFO}
  637.   CERT_PE_IMAGE_DIGEST_DEBUG_INFO             = $01;
  638.   {$EXTERNALSYM CERT_PE_IMAGE_DIGEST_RESOURCES}
  639.   CERT_PE_IMAGE_DIGEST_RESOURCES              = $02;
  640.   {$EXTERNALSYM CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO}
  641.   CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO        = $04;
  642.  
  643.   {$EXTERNALSYM CERT_SECTION_TYPE_ANY}
  644.   CERT_SECTION_TYPE_ANY                       = $FF;      { Any Certificate type }
  645.  
  646. type
  647.   {$EXTERNALSYM DIGEST_HANDLE}
  648.   DIGEST_HANDLE = Pointer;
  649.   TDigestHandle = DIGEST_HANDLE;
  650.  
  651. type
  652.   {$EXTERNALSYM DIGEST_FUNCTION}
  653.   DIGEST_FUNCTION = function(refdata: TDigestHandle; pData: PByte;
  654.     dwLength: DWORD): Bool; stdcall;
  655.   TDigestFunction = DIGEST_FUNCTION;
  656.  
  657. {$EXTERNALSYM ImageGetDigestStream}
  658. function ImageGetDigestStream(FileHandle: THandle; DigestLevel: DWORD;
  659.   DigestFunction: TDigestFunction; DigestHandle: TDigestHandle): Bool; stdcall;
  660.  
  661. {$EXTERNALSYM ImageAddCertificate}
  662. function ImageAddCertificate(FileHandle: THandle;
  663.   var Certificate: PWinCertificate; var Index: DWORD): Bool; stdcall;
  664.  
  665. {$EXTERNALSYM ImageRemoveCertificate}
  666. function ImageRemoveCertificate(FileHandle: THandle; Index: DWORD): Bool; stdcall;
  667.  
  668. {$EXTERNALSYM ImageEnumerateCertificates}
  669. function ImageEnumerateCertificates(FileHandle: THandle; TypeFilter: Word;
  670.   CertificateCount, Indices, IndexCount: PDWORD): Bool; stdcall;
  671.  
  672. {$EXTERNALSYM ImageGetCertificateData}
  673. function ImageGetCertificateData(FileHandle: THandle; CertificateIndex: DWORD;
  674.   Certificate: PWinCertificate; var RequiredLength: DWORD): Bool; stdcall;
  675.  
  676. {$EXTERNALSYM ImageGetCertificateHeader}
  677. function ImageGetCertificateHeader(FileHandle: THandle; CertificateIndex: DWORD;
  678.   var Certificateheader: PWinCertificate): Bool; stdcall;
  679.  
  680. implementation
  681.  
  682. const
  683.   ImagehlpLib = 'IMAGEHLP.DLL';
  684.  
  685. function BindImage;                     external ImagehlpLib name 'BindImage';
  686. function BindImageEx;                   external ImagehlpLib name 'BindImageEx';
  687. function CheckSumMappedFile;            external ImagehlpLib name 'CheckSumMappedFile';
  688. function EnumerateLoadedModules;        external ImagehlpLib name 'EnumerateLoadedModules';
  689. function FindDebugInfoFile;             external ImagehlpLib name 'FindDebugInfoFile';
  690. function FindExecutableImage;           external ImagehlpLib name 'FindExecutableImage';
  691. function GetImageConfigInformation;     external ImagehlpLib name 'GetImageConfigInformation';
  692. function GetImageUnusedHeaderBytes;     external ImagehlpLib name 'GetImageUnusedHeaderBytes';
  693. function GetTimestampForLoadedLibrary;  external ImagehlpLib name 'GetTimestampForLoadedLibrary';
  694. function ImageAddCertificate;           external ImagehlpLib name 'ImageAddCertificate';
  695. function ImageDirectoryEntryToData;     external ImagehlpLib name 'ImageDirectoryEntryToData';
  696. function ImageEnumerateCertificates;    external ImagehlpLib name 'ImageEnumerateCertificates';
  697. function ImageGetCertificateData;       external ImagehlpLib name 'ImageGetCertificateData';
  698. function ImageGetCertificateHeader;     external ImagehlpLib name 'ImageGetCertificateHeader';
  699. function ImageGetDigestStream;          external ImagehlpLib name 'ImageGetDigestStream';
  700. function ImagehlpApiVersion;            external ImagehlpLib name 'ImagehlpApiVersion';
  701. function ImagehlpApiVersionEx;          external ImagehlpLib name 'ImagehlpApiVersionEx';
  702. function ImageLoad;                     external ImagehlpLib name 'ImageLoad';
  703. function ImageNtHeader;                 external ImagehlpLib name 'ImageNtHeader';
  704. function ImageRemoveCertificate;        external ImagehlpLib name 'ImageRemoveCertificate';
  705. function ImageRvaToSection;             external ImagehlpLib name 'ImageRvaToSection';
  706. function ImageRvaToVa;                  external ImagehlpLib name 'ImageRvaToVa';
  707. function ImageUnload;                   external ImagehlpLib name 'ImageUnload';
  708. function MakeSureDirectoryPathExists;   external ImagehlpLib name 'MakeSureDirectoryPathExists';
  709. function MapAndLoad;                    external ImagehlpLib name 'MapAndLoad';
  710. function MapDebugInformation;           external ImagehlpLib name 'MapDebugInformation';
  711. function MapFileAndCheckSumA;           external ImagehlpLib name 'MapFileAndCheckSumA';
  712. function MapFileAndCheckSumW;           external ImagehlpLib name 'MapFileAndCheckSumW';
  713. function MapFileAndCheckSum;           external ImagehlpLib name 'MapFileAndCheckSumA';
  714. function ReBaseImage;                   external ImagehlpLib name 'ReBaseImage';
  715. function RemovePrivateCvSymbolic;       external ImagehlpLib name 'RemovePrivateCvSymbolic';
  716. procedure RemoveRelocations;            external ImagehlpLib name 'RemoveRelocations';
  717. function SearchTreeForFile;             external ImagehlpLib name 'SearchTreeForFile';
  718. function SetImageConfigInformation;     external ImagehlpLib name 'SetImageConfigInformation';
  719. function SplitSymbols;                  external ImagehlpLib name 'SplitSymbols';
  720. function StackWalk;                     external ImagehlpLib name 'StackWalk';
  721. function SymCleanup;                    external ImagehlpLib name 'SymCleanup';
  722. function SymEnumerateModules;           external ImagehlpLib name 'SymEnumerateModules';
  723. function SymEnumerateSymbols;           external ImagehlpLib name 'SymEnumerateSymbols';
  724. function SymFunctionTableAccess;        external ImagehlpLib name 'SymFunctionTableAccess';
  725. function SymGetModuleBase;              external ImagehlpLib name 'SymGetModuleBase';
  726. function SymGetModuleInfo;              external ImagehlpLib name 'SymGetModuleInfo';
  727. function SymGetOptions;                 external ImagehlpLib name 'SymGetOptions';
  728. function SymGetSearchPath;              external ImagehlpLib name 'SymGetSearchPath';
  729. function SymGetSymFromAddr;             external ImagehlpLib name 'SymGetSymFromAddr';
  730. function SymGetSymFromName;             external ImagehlpLib name 'SymGetSymFromName';
  731. function SymGetSymNext;                 external ImagehlpLib name 'SymGetSymNext';
  732. function SymGetSymPrev;                 external ImagehlpLib name 'SymGetSymPrev';
  733. function SymInitialize;                 external ImagehlpLib name 'SymInitialize';
  734. function SymLoadModule;                 external ImagehlpLib name 'SymLoadModule';
  735. function SymRegisterCallback;           external ImagehlpLib name 'SymRegisterCallback';
  736. function SymSetOptions;                 external ImagehlpLib name 'SymSetOptions';
  737. function SymSetSearchPath;              external ImagehlpLib name 'SymSetSearchPath';
  738. function SymUnDName;                    external ImagehlpLib name 'SymUnDName';
  739. function SymUnloadModule;               external ImagehlpLib name 'SymUnloadModule';
  740. function TouchFileTimes;                external ImagehlpLib name 'TouchFileTimes';
  741. function UnDecorateSymbolName;          external ImagehlpLib name 'UnDecorateSymbolName';
  742. function UnMapAndLoad;                  external ImagehlpLib name 'UnMapAndLoad';
  743. function UnmapDebugInformation;         external ImagehlpLib name 'UnmapDebugInformation';
  744. function UpdateDebugInfoFile;           external ImagehlpLib name 'UpdateDebugInfoFile';
  745. function UpdateDebugInfoFileEx;         external ImagehlpLib name 'UpdateDebugInfoFileEx';
  746.  
  747. end.
  748.